#!/usr/bin/env python

import consultasBD
import utiles
import Imprimir
from decimal import Decimal, getcontext, ROUND_UP
import sincronizar_tabla  

textoRecibo  = []

def infoClientes(id,condicion1,condicion2):
    textobuscado = " idcliente = '"+id+"'"
    #resultado1 contiene los datos del cliente
    resultado1 = consultasBD.executaSQL(None,'*','cliente',str(textobuscado))
    sentenciaSQL = "select * from vtas_ctasctes where idcliente='"+id+"' "+condicion1+" "+condicion2+" order by vencimiento"
    #resultado2 contiene los datos de la deuda
    resultado2 = consultasBD.ordenCrudaDict(sentenciaSQL)
    return (resultado1, resultado2)

def infoClientes2(consultaSQL):
    resultado = consultasBD.ordenCrudaDict(consultaSQL)
    if len(resultado) <= 1:
        utiles.mensaje(None,"No hay informacion con los\ncriterios de busqueda informados")
        resultado = ""
    return resultado

#*******************************************************************************
    
def calculoRecargo():
    #getcontext().prec = 2 #precision : numero de decimales
    #getcontext().rounding = ROUND_UP #factor de redondeo : ROUND_UP -> hacia arriba
    utiles.logOperaciones("CtasCtes.py: calculoRecargo")
    decimales = Decimal('0.01')
    fechaActual = utiles.getfechaInverse()
    nroSucursal = utiles.getSucursalActiva()
    totalRecargosAplicados = 0
    totalRecargosOmitidos = 0
##    #si hoy no es un dia laboral, no se ejecutan recargos a las cuotas vencidas
##    if utiles.isDiaNoLaboral(utiles.strToDate(fechaActual)):
##        texto  = "ATENCION: hoy no es una fecha laboral\n"
##        texto += "No se pueden ejecutar actualizaciones"
##        utiles.mensaje(None,texto)
##        return
    
    texto  = "ATENCION: La fecha de hoy es "+utiles.getfecha()+"\n\n" 
    texto += "Se procesaran recargos para cuotas impagas vencidas.\n\n"
    texto += "DESEA CONTINUAR?"
    #if not utiles.dialog2(self,texto):
    #    print "Operacion de calculo de recargo cancelada"
    #    utiles.logOperaciones("CtasCtes.py: calculoRecargo -> CANCELADO")
    #    return
    utiles.logOperaciones("CtasCtes.py: calculoRecargo -> PROCESANDO")

    #se cargan todas las cuotas impagas de fecha de vencimiento menores a la actual del sistema
    #****************************************************************************
    tabla       = "vtas_ctasctes"
    campos      = "idventa,nrofactura,vencimiento,idformapagos,cuota,montocuota,montopagado,idrecargo,idcliente"
    condicion   = "vencimiento < '%s' AND montocuota <> montopagado AND montocuota > 0 AND idrecargo IS NULL" % (fechaActual)
    consultaSQL = "SELECT %s FROM %s WHERE %s" % (campos,tabla,condicion)
    cuentasImpagas = consultasBD.ordenCrudaDict(consultaSQL)
    print consultaSQL
    print "TOTAL DE CUOTAS IMPAGAS:",len(cuentasImpagas)

    #****************************************************************************
    if cuentasImpagas == None:
        texto = "No hay cuentas impagas vencidas"
        print texto
        utiles.mensaje(None,texto)
        return 0
        
    for registro in cuentasImpagas:
        fechaRecargo = fechaActual #se supone que estamos en dia laboral

        #determino el indice de recargo a aplicar y lo aplico guardandolo en monto
        #****************************************************************************
        tabla       = "parametros"
        campos      = "" #se determina con el "if" siguiente cual campo de la tabla consultar
        if registro['montopagado'] == 0:
            campos  = "recargototal" 
        else:
            campos  = "recargoparcial"
        condicion   = "sucursal = '"+nroSucursal+"'"
        consultaSQL = "SELECT "+campos+" FROM "+tabla+" WHERE "+condicion
        
        indiceRecargo = consultasBD.ordenCruda(consultaSQL)
        print consultaSQL
        consultasBD.commit()
        #****************************************************************************
        indiceRecargo = Decimal(str(indiceRecargo[0][0]))
        resto = ( Decimal(str(registro['montocuota'])) - Decimal(str(registro['montopagado'])) )
        monto = Decimal(str(round(( resto * indiceRecargo / Decimal("100") ),1)))
        if monto <= Decimal("0.00"): monto = Decimal("0.05")

        print registro
        print indiceRecargo
        print resto
        print monto
        #return

        fechacuota = str(registro['vencimiento'])
        fechacuota = fechacuota[-2:]+"-"+fechacuota[5:7]+"-"+fechacuota[:4]
        descripcion = "Cta "+str(registro['cuota'])+" vencida: "+fechacuota
        if registro['idrecargo'] == None:
            #calculo de fechas de vencimientos de futuros recargos
            #1ro - determino tipo de cuenta corriente: CC (Cta Cte) o SU (Sussan) y extraigo dia de la fecha
            if registro['idformapagos'][:2] == "SU":
                diacuota = utiles.getFechaVencimientoTarjeta() #los vencimientos de las tarjetas
                aux = str(utiles.getFechaLaboralMesSiguiente(utiles.strToDate(fechaActual)))
                fechaSiguienteRecargo = aux[:8]+diacuota
                fechaSiguienteRecargo = utiles.strToDate(fechaSiguienteRecargo)
                if utiles.isDiaNoLaboral(fechaSiguienteRecargo):
                    fechaSiguienteRecargo = str(utiles.getfechaDiaLaboralSiguiente(fechaSiguienteRecargo))
                else:
                    fechaSiguienteRecargo = str(fechaSiguienteRecargo)
            else:
                diacuota = str(registro['vencimiento'])[-2:] #el vencimiento de cada cuota
                print diacuota
                if diacuota=="31" : diacuota="30"
                fechaSiguienteRecargo = fechaRecargo[:8]+diacuota
                print fechaSiguienteRecargo
                fechaSiguienteRecargo = utiles.strToDate(fechaSiguienteRecargo)
                fechaSiguienteRecargo = str(utiles.getFechaLaboralMesSiguiente(fechaSiguienteRecargo))
            

            #1er recargo que se aplica a una cuota vencida
            #debe insertarse el recargo en vtas_recargos y updatearse idrecargo en vtas_ctasctes
            #****************************************************************************
            idrecargo = utiles.secuencia("vtas_recargos",nroSucursal)
            tablaycampos  = "vtas_recargos(idrecargo,fecharecargo,monto,descripcion,fechasiguienterecargo,idcliente)"
            valorescampos = "('%s','%s',%s,'%s','%s','%s')" % (idrecargo,fechaRecargo,str(monto),descripcion,fechaSiguienteRecargo,registro['idcliente'])
            consultaSQL   = "INSERT INTO "+tablaycampos+" VALUES "+valorescampos
            ultimoid      = consultasBD.executa(None,consultaSQL)
            #****************************************************************************
            #actualizacion en vtas_ctasctes
            tabla          = "vtas_ctasctes"
            camposyvalores = "idrecargo = '"+idrecargo+"'"
            condicion      = "idventa = '"+registro['idventa']+"' AND vencimiento = '"+str(registro['vencimiento'])+"'"
            condicion     += " AND idformapagos = '"+registro['idformapagos']+"' AND montocuota = '"+str(registro['montocuota'])+"'"
            condicion     += " AND nrofactura = '"+str(registro['nrofactura'])+"'"
            consultaSQL = "UPDATE "+tabla+" SET "+camposyvalores+" WHERE "+condicion
            ultimoid = consultasBD.executa(None,consultaSQL)
            #****************************************************************************
            totalRecargosAplicados += 1
        else:
            #recargos sucesivos
            idrecargoanterior = registro['idrecargo']
            resultado = {}
            #la unica forma de salir del bucle es que en algun momento se llegue al final de la cola
            #teniendo resultado['idrecargo2'] == None
            while True:
                #****************************************************************************
                tabla       = "vtas_recargos"
                campos      = "idrecargo,fecharecargo,idrecargo2,fechasiguienterecargo,idcliente"
                condicion   = "idrecargo = '"+str(idrecargoanterior)+"'"
                consultaSQL = "SELECT "+campos+" FROM "+tabla+" WHERE "+condicion
                resultado = consultasBD.ordenCrudaDict(consultaSQL)
                #****************************************************************************
                if resultado != None:
                    resultado = resultado[0]
                    if resultado['idrecargo2'] == None:
                        break #se llego al final de la cola de recargos (cuando hay mas de uno)
                    else:
                        idrecargoanterior = resultado['idrecargo2']
            
            if resultado != None: #esta verificacion no tiene sentido porque se sale del bucle si hay un resultado
                fechaRecargo          = fechaActual
                fechaRecargoSiguiente = str(resultado['fechasiguienterecargo'])
                if fechaRecargoSiguiente == fechaRecargo:
                    #hoy es la fecha en la que se aplica el recargo
                    #1ro - determino tipo de cuenta corriente: CC (Cta Cte) o SU (Sussan) y extraigo dia de la fecha
                    if registro['idformapagos'][:2] == "SU":
                        diacuota = utiles.getFechaVencimientoTarjeta() #los vencimientos de las tarjetas
                        aux = str(utiles.getFechaLaboralMesSiguiente(utiles.strToDate(fechaActual)))
                        fechaSiguienteRecargo = aux[:8]+diacuota
                        fechaSiguienteRecargo = utiles.strToDate(fechaSiguienteRecargo)
                        if utiles.isDiaNoLaboral(fechaSiguienteRecargo):
                            fechaSiguienteRecargo = str(utiles.getfechaDiaLaboralSiguiente(fechaSiguienteRecargo))
                        else:
                            fechaSiguienteRecargo = str(fechaSiguienteRecargo)
                    else:
                        diacuota = str(registro['vencimiento'])[-2:] #el vencimiento de cada cuota
                        mescuota = str(registro['vencimiento'])[5:7]

                        if (diacuota == "31") and (mescuota in ["03","05","08","10"]):
                            diacuota = "30"
                        elif (diacuota >= "29") and (mescuota == "01"):
                            diacuota = "28"
                            
                        fechaSiguienteRecargo = fechaRecargo[:8]+diacuota
                        fechaSiguienteRecargo = utiles.strToDate(fechaSiguienteRecargo)
                        fechaSiguienteRecargo = str(utiles.getFechaLaboralMesSiguiente(fechaSiguienteRecargo))
                        
                    #debe insertarse el recargo en vtas_recargos y updatearse el registro anterior de la cola
                    #****************************************************************************
                    idrecargo = utiles.secuencia("vtas_recargos",nroSucursal)
                    tablaycampos  = "vtas_recargos(idrecargo,fecharecargo,monto,descripcion,fechasiguienterecargo,idcliente)"
                    valorescampos = "('%s','%s',%s,'%s','%s','%s')" % (idrecargo,fechaRecargo,str(monto),descripcion,fechaSiguienteRecargo,resultado['idcliente'])
                    consultaSQL   = "INSERT INTO "+tablaycampos+" VALUES "+valorescampos
                    ultimoid      = consultasBD.executa(None,consultaSQL)
                    #****************************************************************************
                    #actualizacion en vtas_recargos
                    tabla          = "vtas_recargos"
                    camposyvalores = "idrecargo2 = '"+idrecargo+"'"
                    condicion      = "idrecargo = '"+str(resultado['idrecargo'])+"'"
                    consultaSQL = "UPDATE "+tabla+" SET "+camposyvalores+" WHERE "+condicion
                    ultimoid = consultasBD.executa(None,consultaSQL)
                    #****************************************************************************
                    totalRecargosAplicados += 1
                else:
                    #el recargo leido corresponde al de este mes, no hay que volver a aplicar recargo alguno
                    totalRecargosOmitidos += 1
                    pass
            else:
                #no deberia salirse nunca por aqui
                texto  = "ATENCION: hay un problema con la BD"
                utiles.mensaje(None,texto)
                return False

    mifecha = str(fechaActual)
    mifecha = mifecha[-2:]+"-"+mifecha[5:7]+"-"+mifecha[:4]
    texto  = "Fecha actual      : "+mifecha+"\n"
    texto += "Recargos aplicados: "+str(totalRecargosAplicados)+"\n"
    texto += "Recargos omitidos : "+str(totalRecargosOmitidos)
    utiles.mensaje(None,texto)
    return True

#*******************************************************************************

def botonImprimirCtaCte(idcliente,listaDesde,listaRango):

    print "IMPRIMIR CUENTA CORRIENTE"
    utiles.logOperaciones("IMPRIMIR CUENTA CORRIENTE")

    condicionCliente = " idcliente = '%s'" % (idcliente)
    condicionFecha = ""
    condicionCuota = ""

    if listaDesde[0] and not listaRango[0]: #solo consulta completa desde una fecha X
        condicionFecha = " AND vencimiento >= '%s'" % listaDesde[1]
    elif listaDesde[0] and listaRango[0]: #consulta completa y por rango de fecha
        condicionFecha = " AND vencimiento BETWEEN '%s' AND '%s'" % (listaRango[1],listaRango[2])
    elif not listaDesde[0] and listaRango[0]:
        condicionFecha = " AND vencimiento BETWEEN '%s' AND '%s'" % (listaRango[1],listaRango[2])  
        condicionCuota = " AND montocuota <> montopagado"
    else:
        condicionCuota = " AND montocuota <> montopagado"
    print "=>",condicionFecha
    
    
    consultaSQL = "SELECT * FROM vtas_ctasctes WHERE"+condicionCliente+condicionFecha+condicionCuota+" ORDER BY vencimiento"
    resultados = consultasBD.ordenCrudaDict(consultaSQL)
    if len(resultados) == 0:
        texto  = "Codigo de Cliente no encontrado\n"
        texto += "o el Cliente no registra operaciones\n"
        texto += "para el periodo indicado."
        utiles.mensaje(None,texto)
        return

    saldo = Decimal("0.00")

    columnas = ["Fecha","Id Vta","Factura","Total","Suc","Cuota","Venc.","Id","Valor","Pagado","Saldo","Recibo","Impago"]
    detalleCtaCte = []
    
    for registro in resultados:
        renglon = []
        
        idventa = str(registro['idventa'])
        nrofactura = str(registro['nrofactura'])

        consultaSQL = "SELECT fecha,totalfactura,sucursal FROM ventas WHERE idcliente = '%s' AND idventa = '%s' AND nrofactura = '%s'" % (idcliente,idventa,nrofactura)
        datosFactura = consultasBD.ordenCrudaDict(consultaSQL)
        if len(datosFactura) == 0:
            fecha = ""
            totalfactura = ""
            sucursal = ""
        else:
            datosFactura = datosFactura[0]
            
            fecha = str(utiles.convertirFecha(datosFactura['fecha']))
            totalfactura = str(datosFactura['totalfactura'])
            sucursal  = str(datosFactura['sucursal'])
        
        #encabezado renglon
        renglon.append(fecha)
        renglon.append(idventa)
        renglon.append(nrofactura)
        renglon.append(totalfactura)
        renglon.append(sucursal)

        #detalle cuota
        cuota = str(registro['cuota'])
        vencimiento = str(utiles.convertirFecha(registro['vencimiento']))
        idformapago = str(registro['idformapagos'])
        montocuota = str(registro['montocuota'])
        montopagado = str(registro['montopagado'])
        idrecibo = registro['idrecibo']
        if idrecibo == None: idrecibo = ""
        
        subtotal = Decimal(montocuota) - Decimal(montopagado)
        if subtotal != Decimal("0.00"):
            marcaImpaga = "*"
        else:
            marcaImpaga = ""
        saldo += subtotal
        
        renglon.append(cuota)
        renglon.append(vencimiento)
        renglon.append(idformapago)
        renglon.append(montocuota)
        renglon.append(montopagado)
        renglon.append(str(saldo))
        renglon.append(idrecibo)
        renglon.append(marcaImpaga)
        
        detalleCtaCte.append(renglon)
        
        idrecargo = registro['idrecargo']
        print "idrecargo:" + str(idrecargo)
        while idrecargo != None:
            renglon = ["","","","",""]
            
            consultaSQL = "SELECT fecharecargo,monto,montopagado,idrecibo,idrecargo2 FROM vtas_recargos WHERE idrecargo = '%s'" % (idrecargo)
            datosRecargo = consultasBD.ordenCrudaDict(consultaSQL)
            if len(datosRecargo) == 0:
                break
            datosRecargo = datosRecargo[0]
            
            cuota = "R"
            vencimiento = str(utiles.convertirFecha(datosRecargo['fecharecargo']))
            idformapagos = ""
            montocuota = str(datosRecargo['monto'])
            montopagado = str(datosRecargo['montopagado'])
            idrecibo = datosRecargo['idrecibo']
            if idrecibo == None: idrecibo = ""
        
            subtotal = Decimal(montocuota) - Decimal(montopagado)
            if subtotal != Decimal("0.00"):
                marcaImpaga = "*"
            else:
                marcaImpaga = ""
            saldo += subtotal

            renglon.append(cuota)
            renglon.append(vencimiento)
            renglon.append(idformapago)
            renglon.append(montocuota)
            renglon.append(montopagado)
            renglon.append(str(saldo))
            renglon.append(idrecibo)
            renglon.append(marcaImpaga)

            detalleCtaCte.append(renglon)
            
            idrecargo = datosRecargo['idrecargo2']
    
    nombre = utiles.obtenerNombreCliente(idcliente)
    
    import Vista
    nombre_vista = 'Estado de la Cuenta Corriente del cliente: %s %s' % (idcliente,nombre)
    dlg = Vista.Vista(None, nombre_vista)
    dlg.cargar_celdas(detalleCtaCte, columnas)
    try:
        dlg.ShowModal()
    finally:
        dlg.Destroy()

#*******************************************************************************

def actualizarAcumulados(idcliente,acumulados,totalventa):

    acumulado = Decimal(acumulados)
    totalventa = Decimal(totalventa)
    nuevoacumulado = acumulado + totalventa
    consultaSQL = "UPDATE cliente SET acumulados = '%s' WHERE idcliente = '%s'" % (str(nuevoacumulado),idcliente)
    consultasBD.executaSinCommit(None, consultaSQL)
    sincronizar_tabla.addChange(sql=consultaSQL)      
    return nuevoacumulado

#*******************************************************************************
